// ----------------------------------------------------------------------------
/**
	File: gopherii.cpp
	Author: Zef RosnBrick
	Archive: UVa
	Problem Number: 10080
*/
// ----------------------------------------------------------------------------

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <map>
#include <queue>
#include <complex>

#define EPS 1E-10
#define INF 1000000000

using namespace std;

typedef complex<double> pt;

class node;
int num_nodes;
node *nodes[102];

class node
{
	public:
		node(pt p) : p(p), prev(NULL) {}
		pt p;
		map<node *, int> edges;
		node *prev;
};

node *source, *sink;

bool bfs()
{
	for (int i = 0; i < num_nodes; i++)
		nodes[i]->prev = NULL;

	queue<node *> q;
	q.push(source);
	source->prev = source;

	while (!q.empty())
	{
		node *c = q.front();
		q.pop();

		if (c == sink)
			return true;

		for (map<node *, int>::iterator it = c->edges.begin(); it != c->edges.end(); ++it)
		{
			node *i = it->first;
			if (i->prev != NULL || it->second <= 0)
				continue;
			i->prev = c;
			q.push(i);
		}
	}

	return false;
}

int update()
{
	int ret = INF;

	for (node *c = sink, *p = c->prev; c != source; c = p, p = c->prev)
	{
		ret = min(ret, p->edges[c]);
	}

	for (node *c = sink, *p = c->prev; c != source; c = p, p = c->prev)
	{
		p->edges[c] -= ret;
		c->edges[p] += ret;
	}

	return ret;
}

int max_flow()
{
	int ret = 0;

	while (bfs())
	{
		ret += update();
	}

	return ret;
}

int main()
{
	int caseno = 0, n, m;
	double s, v, x, y;

	while (++caseno)
	{
		if (!(cin >> n >> m >> s >> v))
			return 0;

		num_nodes = n + m + 2;
		source = nodes[num_nodes - 2] = new node(pt(0.0, 0.0)); 
		sink = nodes[num_nodes - 1] = new node(pt(0.0, 0.0)); 

		for (int i = 0; i < n + m; i++)
		{
			cin >> x >> y;
			nodes[i] = new node(pt(x, y));

			if (i < n) // gopher
			{
				source->edges[nodes[i]] = 1;
			}
			else // hole
			{
				nodes[i]->edges[sink] = 1;
				for (int j = 0; j < n; j++)
					if (abs(nodes[i]->p - nodes[j]->p) < v * s + EPS)
					{
						nodes[j]->edges[nodes[i]] = INF;
					}
			}
		}

		cout << (n - max_flow()) << endl;
	}
}
